#include <stdio.h>
#include <stdlib.h>

// 1. 定义“父类”结构体：Animal（包含“方法”的函数指针）
typedef struct Animal {
	// 函数指针：模拟“发声”方法（返回void，无参数）
	void (*Speak)(struct Animal* self);
} Animal;

// 2. 定义“子类”结构体：Dog（继承Animal）
typedef struct Dog {
	Animal parent; // 第一个成员必须是父类结构体，模拟继承
	// 可以添加Dog特有的成员（如名字）
	char* name;
} Dog;

// 3. 定义“子类”结构体：Cat（继承Animal）
typedef struct Cat {
	Animal parent; // 继承父类
	char* name;
} Cat;

// 4. 实现Dog的Speak方法（重写父类）
void Dog_Speak(Animal* self) {
	// 将Animal*转换为Dog*（因为parent是Dog的第一个成员，地址相同）
	Dog* dog = (Dog*)self;
	printf("%s: 汪汪汪\n", dog->name);
}

// 5. 实现Cat的Speak方法（重写父类）
void Cat_Speak(Animal* self) {
	Cat* cat = (Cat*)self;
	printf("%s: 喵喵喵\n", cat->name);
}

// 6. 初始化Dog对象的函数（相当于构造函数）
Dog* Dog_Create(char* name) {
	Dog* dog = (Dog*)malloc(sizeof(Dog));
	dog->name = name;
	// 绑定Dog自己的Speak方法到父类的函数指针
	dog->parent.Speak = Dog_Speak;
	return dog;
}

// 7. 初始化Cat对象的函数
Cat* Cat_Create(char* name) {
	Cat* cat = (Cat*)malloc(sizeof(Cat));
	cat->name = name;
	cat->parent.Speak = Cat_Speak; // 绑定Cat的Speak方法
	return cat;
}

// 8. 统一接口：通过父类指针调用，实现多态
void MakeSound(Animal* animal) {
	animal->Speak(animal); // 调用的是子类重写后的方法
}

int main() {
	// 创建子类对象
	Dog* dog = Dog_Create("旺财");
	Cat* cat = Cat_Create("咪酱");
	
	// 用父类指针接收子类对象（向上转型）
	Animal* animal1 = (Animal*)dog;
	Animal* animal2 = (Animal*)cat;
	
	// 同一接口，不同行为
	MakeSound(animal1); // 输出：旺财: 汪汪汪
	MakeSound(animal2); // 输出：咪酱: 喵喵喵
	
	// 释放内存
	free(dog);
	free(cat);
	return 0;
}
